package m

import (
	"GameServer/Game/cache"
	"GameServer/Game/dbmodule"
	"GameServer/Game/errors"

	"github.com/globalsign/mgo/bson"
	log "github.com/sirupsen/logrus"
)

var CodeType struct {
	Once int64 // 兑换码只能领一次
	Many int64 // 兑换码能领多次
} = struct {
	Once int64
	Many int64
}{
	Once: 1,
	Many: 2,
}

// 兑换码
type ExCode struct {
	BaseM
	Id    string `bson:"_id" json:"_id"`     // 兑换码
	APId  int64  `bson:"apId" json:"apId"`   // 活动礼包id
	CType int64  `bson:"cType" json:"cType"` // 类型
}

type KV struct {
	Key   int64 `bson:"key" json:"key"`     // 键
	Value int64 `bson:"value" json:"value"` // 值
}

// 活动礼包
type AcitvPack struct {
	BaseM
	Id        int64  `bson:"_id" json:"_id"`             // id
	Goods     []KV   `bson:"goods" json:"goods"`         // 兑换道具
	PeopleNum int64  `bson:"peopleNum" json:"peopleNum"` // 兑换人数
	CloseTime int64  `bson:"closeTime" json:"closeTime"` // 截止日期
	CodeNum   int64  `bson:"codeNum" json:"codeNum"`     // 生成兑换码的数量
	Desc      string `bson:"desc" json:"desc"`           // 描述
}

// 记录用户使用过的兑换码，只记录类型2的兑换码
type UserCode struct {
	BaseM
	Uid     bson.ObjectId   `bson:"_id" json:"_id"`         // 用户uid
	ActivId map[int64]int64 `bson:"activId" json:"activId"` // 领取过的活动id
}

// 兑换码：创建
func NewExCode() cache.EntryI {
	return &ExCode{}
}

// 兑换码：保存信息
func (ec *ExCode) Save() (err error) {
	err = dbmodule.MgoDB.GameDB.Upsert("ExCode", bson.M{"_id": ec.Id}, ec)
	if err != nil {
		return
	}
	return
}

// 兑换码：加载
func (ec *ExCode) Load(key interface{}) (err error) {
	switch key.(type) {
	case string:
		ec.Id = key.(string)
	default:
		log.WithFields(log.Fields{
			"method": "ExCode_Load",
			"data":   key,
		}).Error("无效的key load")
		return errors.New("无效的key load")
	}
	return ec.LoadData()
}

// 兑换码：加载数据
func (ec *ExCode) LoadData() (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("ExCode", bson.M{"_id": ec.Id}, nil, &ec)
	if err != nil {
		if err.Error() == "not found" {
			return nil
		}
		return err
	}
	return
}

// 兑换码：更新数据
func (ec *ExCode) Update(val *ExCode) {
	Cache.Put("ExCode", val.Id, val) //arG.GroupId.Hex()
	val.UpdateData()
}

// 兑换码：删除分组
func (ec *ExCode) Delete() (err error) {
	Cache.Remove("ExCode", ec.Id)
	return dbmodule.MgoDB.GameDB.Remove("ExCode", bson.M{"_id": ec.Id})
}

// 活动礼包：创建
func NewAcitvPack() cache.EntryI {
	return &AcitvPack{}
}

// 活动礼包：保存信息
func (ap *AcitvPack) Save() (err error) {
	err = dbmodule.MgoDB.GameDB.Upsert("AcitvPack", bson.M{"_id": ap.Id}, ap)
	if err != nil {
		return
	}
	return
}

// 活动礼包：加载
func (ap *AcitvPack) Load(key interface{}) (err error) {
	switch key.(type) {
	case int64:
		ap.Id = key.(int64)
	default:
		log.WithFields(log.Fields{
			"method": "EAcitvPack_Load",
			"data":   key,
		}).Error("无效的key load")
		return errors.New("无效的key load")
	}
	return ap.LoadData()
}

// 活动礼包：加载数据
func (ap *AcitvPack) LoadData() (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("AcitvPack", bson.M{"_id": ap.Id}, nil, &ap)
	if err != nil {
		if err.Error() == "not found" {
			return nil
		}
		return err
	}
	return
}

// 活动礼包：更新数据
func (ap *AcitvPack) Update(val *AcitvPack) {
	Cache.Put("AcitvPack", val.Id, val) //arG.GroupId.Hex()
	val.UpdateData()
}

// 活动礼包：删除分组
func (ap *AcitvPack) Delete() (err error) {
	Cache.Remove("AcitvPack", ap.Id)
	return dbmodule.MgoDB.GameDB.Remove("AcitvPack", bson.M{"_id": ap.Id})
}

// 活动礼包：创建
func NewUserCode() cache.EntryI {
	return &UserCode{}
}

// 活动礼包：保存信息
func (uc *UserCode) Save() (err error) {
	err = dbmodule.MgoDB.GameDB.Upsert("UserCode", bson.M{"_id": uc.Uid}, uc)
	if err != nil {
		return
	}
	return
}

// 活动礼包：加载
func (uc *UserCode) Load(key interface{}) (err error) {
	switch key.(type) {
	case bson.ObjectId:
		uc.Uid = key.(bson.ObjectId)
	case string:
		uc.Uid = bson.ObjectIdHex(key.(string))
	default:
		log.WithFields(log.Fields{
			"method": "UserCode_Load",
			"data":   key,
		}).Error("无效的key load")
		return errors.New("无效的key load")
	}
	return uc.LoadData()
}

// 活动礼包：加载数据
func (uc *UserCode) LoadData() (err error) {
	err = dbmodule.MgoDB.GameDB.FindOne("UserCode", bson.M{"_id": uc.Uid}, nil, &uc)
	if err != nil {
		if err.Error() == "not found" {
			uc.ActivId = make(map[int64]int64)
			return nil
		}
		return err
	}
	if uc.ActivId == nil {
		uc.ActivId = make(map[int64]int64)
	}
	return
}

// 活动礼包：更新数据
func (uc *UserCode) Update(val *UserCode) {
	Cache.Put("UserCode", val.Uid, val) //arG.GroupId.Hex()
	val.UpdateData()
}

// 活动礼包：删除分组
func (uc *UserCode) Delete() (err error) {
	Cache.Remove("UserCode", uc.Uid)
	return dbmodule.MgoDB.GameDB.Remove("UserCode", bson.M{"_id": uc.Uid})
}
